package main

import (
	"fmt"
	"math"
	"runtime"
	"time"
//	"os"
)

///
///fmt.Printf			可以打印不换行
///fmt.Println			打印并换行，可以任意通过参数拼字符串，Printf不可以
///math.Nextafter 		暂时不知道神马意思
///math.Pi				圆周率π
///math.Sqrt			求开方
///
///
// Name: 				step1.go
// Author: 				伪尘子

func main() {
	fmt.Printf("Now you have %g problems.",
		math.Nextafter(2, 3))
	
	fmt.Println("Pi:",math.Pi);
	
	fmt.Println("what is nextfter",math.Nextafter(3,5))
	
	str,num,bol:=per()
	
	fmt.Println(str,num,bol)
	
	var big float64=Big*0.1
	
	fmt.Println("big:",big)
	
	fmt.Println("Small:",Small)	
	
	fmt.Println("Sqrt",math.Sqrt(4))
	
	
	if v:=-10+5;v>0{
		fmt.Println("10+5 等于 ",v)
	}else if b:=v+10;b>0{
		fmt.Printf("v 等于 %d  b 等于 %d \n",v,b)
	}
//	fmt.Println(v) 在if前端声明的变量只在If内有效，和for有相似
	
	
	fmt.Printf("float num:%f",math.Pow(2,3))//返回神马类型，必须选择正确的格式化操作，如%d(int),%f(float)
	
	///输入字符串
//	input:=make([]byte,1024)
//	//os.Stdin.Read(input)
//	inputStr:=string(input[0:len(input)-1])
//	fmt.Println(inputStr)
	
	
	f:="%T(%v)\n"//%T获取数据类型名称，%v获取数据值
	fmt.Printf(f,0.1,0.1)
	myxx:=xx{2,3,"this is xx"}
	fmt.Printf(f,myxx,myxx.y);
	
	index:=&myxx				///
	index.x=100					///
	index.y=200					///
	fmt.Println(*index)			///在指针上和c/c++一样，但是指针不参与运算
	
	myxx2:=new(xx)				///
	myxx2.x,myxx2.y=20,50		///new 关键字，在我认为，这里只是一个封装的方法，返回一个指针
	fmt.Println(myxx2)			///
	
	mymap:=make(map[int]xx)		///
	mymap[0]=myxx				///我目前认为，make适用于任意场景，可以将对象实例化为非nil,new则只能实例非引用类型
	fmt.Println(mymap)			///
	
	//mymap:=new(map[int]string)
	//(*mymap)[1]="asdf"		非法的
	
	mymap=map[int]xx{0:myxx,1:{x:2,y:3}}	///对于重复给变量赋值，和java一样按照类型赋值
	//mymap=map[int]string{0:"xx"} mymap初始化的类型为[int]xx,就不能用[int]string赋值
	
	xx0,has:=mymap[2230]
	fmt.Println(xx0," has:",has)
	
	
	
	/*
		关于切片 
		切片的好处是可以方便复制数组元素
		可以动态给数组扩容
	*/
	array:=make([]int,3,6)
	array[2]=10
	fmt.Printf("array leng=%d cap=%d value=%v\n",len(array),cap(array),array)
	array2:=array[0:2]
	fmt.Printf("array2 leng=%d cap=%d value=%v\n",len(array2),cap(array2),array2)
	array2=array2[0:cap(array2)]
	fmt.Printf("array2 leng=%d cap=%d value=%v\n",len(array2),cap(array2),array2)
	
	
	/*
		匿函数
		指针接受函数
		func也能做返回类型
	*/
	method:=func(x,y float64) func(int) int{
		fmt.Printf("x=%f \t y=%f \t x+y=%f \t Sqrt=%v ",x,y,math.Sqrt(x*x))
		
		return func(num int)int{
			return 0
		}
	}
	v:=method(1.5,1.6)
	fmt.Printf("method:%v",v(2))
	
	
	/*
		传说中的foreach
	*/
	slince:=[]int{0,2,4,6,8,10}
	for i,v:=range slince{
		fmt.Printf("2*%d=%d\n",i,v)
	}
	
	
	/*
		Switch
		Go风格的函数指针，到处都是这种，看清来爽极了的用法
	*/
	
	switch swt:=runtime.GOOS
	swt{
		case "windows":
			fmt.Println("This pc is window")
		default:
			fmt.Println("I don't know this pc is what type")
	}
	
	
	/*
		time包，对日期访问的
		详情请参考time包
	*/
	tm:=time.Now().Year()
	fmt.Printf("now is %v",tm)
	
	
	
	
}


///
///结构
///
type xx struct{
	
	x int
	y int
	str string
}



const (
	Big = 1<<100
	Small = Big>>99
)

///
///返回双参数
///
func per()(string,int,bool){
	return "中国移动",10086,false
}




func noClose(){

	
}